Motivation

Because OwnedPermits can be passed around separate from the Senders they came from,
it can be useful to be able to check that a value sent on one will go to the intended receiver.

There's currently no way to get a reference to, or clone of, the Sender from an OwnedPermit without sending a message or releasing it, so calling Sender::same_channel() from an OwnedPermit is impossible.

For context, I'm trying to create an implementation of quinn::AsyncUdpSocket backed by channels to support external transports in a project.

AsyncUdpSocket::try_send() just immediately forwards to Sender::try_send() and returns WouldBlock when the channel is full or BrokenPipe if it gets closed (is that right? I can't find what error a socket with the write half closed is meant to return from sendto()). The UdpPoller returned by create_io_poller() is a wrapper around Sender::reserve_owned(), and calling .poll_writable() polls the reserve_owned function until it returns Ready.

The question then becomes: what to do with the permit? I'd like to actually use it in the next try_send() call, because otherwise a task woken by poll_writable() will immediately get a permit just to drop it, which could wake a different task waiting for the same permit. Depending on scheduling, that other task could run first and steal the space, which means at high contention, a task could theoretically get caught in an unbounded loop between poll_writable() and try_send() because it keeps losing its permit.

(As an aside, I think this is a potential flaw in the design of AsyncUdpSocket in general, but I feel like it's much more likely for an mpsc::channel() buffer to fill up and require waiting for space than the actual socket send buffer filling up unless the network interface is ridiculously slow.)

I can just store it in the structure, but by design, multiple tasks are expected to call poll_writable() and try_send() on the same instance, so unless I store the permits in a map keyed by thread ID, there's no way to guarantee that the task that got the permit in poll_writable() will be the one to use it in try_send().

It occurred to me that I should be able to just store the permit in a thread_local!(), but I realized that there's a possible bug there: if two tasks using different channels are running on the same thread and one stores a permit from poll_writable(), the other one could get the permit in .try_send() and end up sending a packet down the wrong channel.

So I realized I needed to check that the permit will actually send to the same channel. I could just store a clone of the Sender alongside the permit, but that's mildly annoying and touches the refcount of the channel, which could actually have nontrivial overhead at high contention.

Solution

I initially thought that OwnedPermit could just gain a get_sender() method, but because of its internal structure, it can't just return a reference directly. It would have to return another owned Sender which would also require touching the refcount.

While that could be a useful addition on its own, I really just needed the ability to call Sender::same_channel(), which is just a trivial pointer comparison, so it made more sense to implement as a dedicated method.

I debated just implementing the method as fn same_channel(&self, sender: &Sender<T>) but that had a potentially confusing asymmetry compared to Sender::same_channel(), so I renamed the method to same_channel_as_sender() for clarity.

For my use-case, I don't actually need OwnedPermit::same_channel(&self, other: &Self) since I'm not dealing with two OwnedPermits at the same time, but it made sense to include as a direct analogue to Sender::same_channel(). However, I'd be fine to delete it under the YAGNI principle.